package service

import (
	"encoding/json"
	"errors"
	"log"

	"admin-system/internal/middleware"
	"admin-system/internal/model"
	"admin-system/pkg/hash"
	"admin-system/pkg/jwt"
)

// AuthService 认证服务
type AuthService struct {
	userService *UserService
}

// NewAuthService 创建认证服务
func NewAuthService() *AuthService {
	return &AuthService{
		userService: NewUserService(),
	}
}

// LoginRequest 登录请求
type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

// LoginResponse 登录响应
type LoginResponse struct {
	Token string    `json:"token"`
	User  *UserInfo `json:"user"`
}

// UserInfo 用户信息
type UserInfo struct {
	ID          uint               `json:"id"`
	Username    string             `json:"username"`
	Name        string             `json:"name"`
	Email       string             `json:"email"`
	Roles       []model.RoleSimple `json:"roles"`
	Permissions []model.Permission `json:"permissions"`
	Menus       []model.MenuTree   `json:"menus"`
}

// Login 用户登录
func (s *AuthService) Login(req *LoginRequest) (*LoginResponse, error) {
	// 根据用户名查找用户
	user, err := s.userService.GetUserByUsername(req.Username)
	if err != nil {
		return nil, errors.New("用户名或密码错误")
	}

	// 检查用户状态
	if user.Status != 1 {
		return nil, errors.New("用户已被禁用")
	}

	// 验证密码
	if !hash.CheckPassword(req.Password, user.Password) {
		return nil, errors.New("用户名或密码错误")
	}

	// 生成JWT令牌
	token, err := jwt.GenerateToken(user.ID, user.Username)
	if err != nil {
		return nil, err
	}

	// 获取用户详细信息
	userInfo, err := s.GetUserInfo(user.ID)
	if err != nil {
		return nil, err
	}

	return &LoginResponse{
		Token: token,
		User:  userInfo,
	}, nil
}

// GetUserInfo 获取用户信息
func (s *AuthService) GetUserInfo(userID uint) (*UserInfo, error) {
	// 获取用户基本信息
	user, err := s.userService.GetUserByID(userID)
	if err != nil {
		return nil, err
	}

	// 获取用户角色
	roles, err := middleware.GetUserRoles(userID)
	if err != nil {
		return nil, err
	}

	// 转换角色格式
	var roleSimples []model.RoleSimple
	for _, role := range roles {
		roleSimples = append(roleSimples, model.RoleSimple{
			ID:   role.ID,
			Name: role.Name,
		})
	}

	// 获取用户权限
	permissions, err := middleware.GetUserPermissions(userID)
	if err != nil {
		return nil, err
	}

	// 获取用户菜单
	menus, err := middleware.GetUserMenus(userID)
	if err != nil {
		return nil, err
	}

	// 调试日志
	log.Printf("获取到的菜单数量: %d", len(menus))
	for _, menu := range menus {
		log.Printf("菜单: ID=%d, Name=%s, Path=%s, ParentID=%v", menu.ID, menu.Name, menu.Path, menu.ParentID)
	}

	// 构建菜单树
	menuTree := s.buildMenuTree(menus)

	// 调试日志
	log.Printf("构建的菜单树数量: %d", len(menuTree))

	return &UserInfo{
		ID:          user.ID,
		Username:    user.Username,
		Name:        user.Name,
		Email:       user.Email,
		Roles:       roleSimples,
		Permissions: permissions,
		Menus:       menuTree,
	}, nil
}

// buildMenuTree 构建菜单树
func (s *AuthService) buildMenuTree(menus []model.Menu) []model.MenuTree {
	// 创建菜单映射
	menuMap := make(map[uint]*model.MenuTree)
	var rootMenus []model.MenuTree

	// 第一遍：创建所有菜单节点
	for _, menu := range menus {
		// 解析Meta JSON
		var meta interface{}
		if menu.Meta != "" {
			json.Unmarshal([]byte(menu.Meta), &meta)
		}

		menuTree := &model.MenuTree{
			ID:        menu.ID,
			ParentID:  menu.ParentID,
			Name:      menu.Name,
			Path:      menu.Path,
			Component: menu.Component,
			Redirect:  menu.Redirect,
			Meta:      meta,
			Sort:      menu.Sort,
			Hidden:    menu.Hidden,
			Children:  []model.MenuTree{},
		}
		menuMap[menu.ID] = menuTree
	}

	// 第二遍：构建树形结构
	var rootMenuIDs []uint
	for _, menu := range menus {
		menuTree := menuMap[menu.ID]
		if menu.ParentID == nil {
			// 根菜单
			log.Printf("添加根菜单: %s", menu.Name)
			rootMenuIDs = append(rootMenuIDs, menu.ID)
		} else {
			// 子菜单
			log.Printf("处理子菜单: %s, ParentID: %d", menu.Name, *menu.ParentID)
			if parent, exists := menuMap[*menu.ParentID]; exists {
				log.Printf("找到父菜单: %s, 添加子菜单: %s", parent.Name, menu.Name)
				parent.Children = append(parent.Children, *menuTree)
			} else {
				log.Printf("警告: 未找到父菜单 ID=%d 对于子菜单 %s", *menu.ParentID, menu.Name)
			}
		}
	}

	// 收集根菜单（在所有子菜单都添加完成后）
	for _, rootID := range rootMenuIDs {
		if rootMenu, exists := menuMap[rootID]; exists {
			rootMenus = append(rootMenus, *rootMenu)
		}
	}

	// 调试：打印最终的菜单树结构
	for i, rootMenu := range rootMenus {
		log.Printf("根菜单 %d: %s, 子菜单数量: %d", i, rootMenu.Name, len(rootMenu.Children))
		for j, child := range rootMenu.Children {
			log.Printf("  子菜单 %d: %s", j, child.Name)
		}
	}

	return rootMenus
}

// RefreshToken 刷新令牌
func (s *AuthService) RefreshToken(token string) (string, error) {
	return jwt.RefreshToken(token)
}

// Logout 用户登出
func (s *AuthService) Logout(userID uint) error {
	// 这里可以实现令牌黑名单等逻辑
	// 目前简单返回成功
	return nil
}
